(function (modules) {
// 14. 定义 webpackJsonpCallback 实现: 合并模块定义,改变 promise 状态执行后续行为
    function webpackJsonpCallback(data) {
// 1 获取需要被动态加载的模块 id
        let chunkIds = data[0]
// 2 获取需要被动态加载的模块依赖关系对象
        let moreModules = data[1]
        let chunkId, resolves = []
// 3 循环判断 chunkIds 里对应的模块内容是否已经完成了加载
        for (let i = 0; i < chunkIds.length; i++) {
            chunkId = chunkIds[i]
            if (
                Object.prototype.hasOwnProperty.call(inStalledChunks, chunkId)
                && inStalledChunks[chunkId]
            ) {
                resolves.push(inStalledChunks[chunkId][0])
            }
// 更新当前 chunk 的状态
            inStalledChunks[chunkId] = 0
        }

        for (moduleId in moreModules) {
            if (Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
// 挂载动态加载的module的依赖关系到传入的modules
                modules[moduleId] = moreModules[moduleId]
            }
        }

        while (resolves.length) {
// 执行操作
            resolves.shift()()
        }
    }

// 1. 用于缓存加载过的模块
    let installedModules = {}

// 15 定义 inStalledChunks 对象,用于标识某个 chunkId 对应的 chunk 是否完成了加载
    let inStalledChunks = {
// 0 -> 已加载
        main: 0
    }

// 2. 定义一个 __webpack_require__ 方法来替换 import require 加载操作
    function __webpack_require__(moduleId) {
// 2-1 判断当前缓存中是否存在要被加载的模块内容,如果存在则直接返回
        if (installedModules[moduleId]) {
            return installedModules[moduleId].exports
        }
// 2-2 如果当前缓存中不存在则需要我们自己定义{} 执行被导入的模块内容加载
        let module = installedModules[moduleId] = {
            i: moduleId,
// 是否被加载
            l: false,
// 导出内容
            exports: {}
        }
// 2-3 调用当前 moduleId 对应的函数,然后完成内容的加载
        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__)
// 2-4 上述方法调用完成后,就可以修改 l 的值,表示当前模块已经加载完成
        module.l = true
// 2-5 加载工作完成之后,要将拿回来的内容返回至调用的位置
        return module.exports
    }

// 3. 定义 m 属性用于保存 modules
    __webpack_require__.m = modules

// 4. 定义 c 属性用于保存cache
    __webpack_require__.c = installedModules

// 5. 定义 o 方法用于判断对象的身上是否存在指定的属性
    __webpack_require__.o = function (object, property) {
        return Object.prototype.hasOwnProperty(object, property)
    }

// 6. 定义 d 方法用于在对象的身上添加指定的属性,同时给该属性提供gatter
    __webpack_require__.d = function (exports, name, getter) {
// 对象身上没有该属性
        if (!__webpack_require__.o(exports, name)) {
            Object.defineProperty(exports, name, {enumerable: true, get: getter})
        }
    }

// 7. 定义 r 方法用于标识当前模块是 es6(esModule) 类型
    __webpack_require__.r = function (exports) {
        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
            Object.defineProperty(exports, Symbol.toStringTag, {value: "Module"})
        }
        Object.defineProperty(exports, '__esModule', {value: true})
    }

// 8. 定义 n 方法用于设置具体的getter
    __webpack_require__.n = function (module) {
        let getter = module && module.__esModule ?
            function getDefault() {
                return module['default']
            } :
            function getModuleExports() {
                return module
            }

// 给getter定义a属性,获取方法是getter
        __webpack_require__.d(getter, 'a', getter)
        return getter
    }

// 17 定义 jsonpScriptSrc 来实现 src 的处理
    function jsonpScriptSrc(chunkId) {
        return __webpack_require__.p + "" + chunkId + ".built.js"
    }

// 16 定义 e 方法用于实现: 实现jsonp来加载内容, 利用promise 实现异步加载操作
    __webpack_require__.e = function (chunkId) {
// 1 定义一个数组用于存放 promise
        let promises = []
// 2 获取 chunkId 对应的 chunk 是否已经完成了加载
        let installedChunkData = inStalledChunks[chunkId]
// 3 依据当前是否已完成加载的状态来执行后续的逻辑
        if (installedChunkData !== 0) {
            if (installedChunkData) {
                promises.push(installedChunkData[2])
            } else {
                let promise = new Promise((resolve, reject) => {
                    installedChunkData = inStalledChunks[chunkId] = [resolve, reject]
                })

// installedChunkData [resolve,reject,promise]
                promises.push(installedChunkData[2] = promise)

// 创建标签
                let script = document.createElement('script')
// 设置src
                script.src = jsonpScriptSrc(chunkId)
// 写入 script 标签
                document.head.appendChild(script)
            }
        }
// 执行promise
        return Promise.all(promises)
    }

// 11. 定义 t 方法,用于加载指定 value 的模块内容,之后对内容进行处理再返回
    __webpack_require__.t = function (value, mode) {
// 01 加载 value 对应的模块内容( value 一般就是模块id)
// 加载之后的内容又重新赋值给 value 变量
        if (mode & 1) {
            value = __webpack_require__(value)
        }
        if (mode & 8) { // 加载了可以直接返回使用的内容
            return value
        }
// 到这说明没有return
        if ((mode & 4) && typeof value === 'object' && value && value.__esModule) {
            return value
        }
// 如果8和4都不成立,则需要自定义 ns 来通过 default 属性返回内容
        let ns = Object.create(null)

        __webpack_require__.r(ns)

        Object.defineProperty(ns, 'default', {enumerable: true, value: value})

        if (mode & 2 && typeof value !== 'string') {
            for (var key in value) {
                __webpack_require__.d(ns, key, function (key) {
                    return value[key]
                }.bind(null, key))
            }
        }

        return ns
    }

// 9. 定义 p 属性,用于保存资源访问路径
    __webpack_require__.p = ""

// 11/2. 定义变量存放数组
    let jsonArray = window['webpackJsonp'] = window['webpackJsonp'] || []

// 12. 保存原生的push方法
    let oldJsonpFunction = jsonArray.push.bind(jsonArray)

// 13. 重写push方法
    jsonArray.push = webpackJsonpCallback

// 10. 调用 __webpack_require__ 方法执行模块导入与加载操作
    return __webpack_require__(__webpack_require__.s = '<%-entryModuleId%>')
})
({
    <%for(let module of modules) {%>
    "<%-module.moduleId%>":
    (function (module, exports, __webpack_require__) {
        <%-module._source%>
    }),
    <%}%>

});